home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / CheapText.C < prev    next >
C/C++ Source or Header  |  1990-12-06  |  9KB  |  431 lines
  1. //$CheapText,CheapTextIter$
  2. #include "CheapText.h"
  3. #include "RegularExp.h"
  4. #include "Port.h"
  5. #include "Error.h"
  6.  
  7. const int cInitCap= 16;
  8.  
  9. static TextChanges changeRec;
  10.  
  11. //---- CheapText ------------------------------------------------------------
  12.  
  13. MetaImpl(CheapText, (T(next), T(size), TV(cont,next), TP(font), 0));
  14.  
  15. CheapText::CheapText(int s, FontPtr fd)
  16. { 
  17.     if (s < 0)
  18.     Error("CheapText::CheapText", "initial size < 0");
  19.     size= max(cInitCap, s);
  20.     cont= new byte[size];
  21.     next= 0; 
  22.     Init(next, fd);
  23. }
  24.  
  25. CheapText::CheapText(byte *t, int len, FontPtr fd)
  26. {   
  27.     int ll= len;
  28.  
  29.     if (ll == -1)
  30.     next= strlen((char*)t); 
  31.     else
  32.     next= len;
  33.  
  34.     size= max (cInitCap,(next / 5 + 1)* 6); // give some initial free space
  35.     cont= new byte[size];
  36.     BCOPY(t, cont, next);
  37.     Init(next, fd);
  38.     font= fd;
  39.     SetTabWidth(fd->Width((byte*)"        ",8));
  40. }
  41.  
  42. void CheapText::Init(int, FontPtr fd)
  43. {
  44.     font= fd;
  45.     SetTabWidth(fd->Width((byte*)"        ",8));
  46.     ink= ePatBlack;
  47. }
  48.  
  49. CheapText::~CheapText()
  50. {
  51.     SafeDelete(cont);
  52. }
  53.  
  54. void CheapText::Cut(int from,int to)
  55. {
  56.     if (!CheckRange(next, from, to))
  57.     return;
  58.  
  59.     BCOPY(&cont[to], &cont[from], next-to);
  60.  
  61.     next-= (to - from);
  62.     if (LowWaterMark()) 
  63.     Expand(size/2);
  64.     Text::Cut(from, to);
  65.     Send(cIdNone, eTextDeleted, changeRec(from, to));     
  66. }
  67.  
  68. void CheapText::Paste(TextPtr paste, int from, int to)
  69. {
  70.     CheapText *ct;
  71.     byte *buf= 0;
  72.  
  73.     if (!paste->IsKindOf(CheapText)) { // try to convert
  74.     int s= paste->Size();
  75.     buf= new byte[s+1];
  76.     paste->CopyInStr(buf, s+1, 0, s);
  77.     ct= new CheapText(buf, s);
  78.     } else
  79.     ct = (CheapText *)paste; 
  80.  
  81.     int shift= ct->next - (to - from);
  82.  
  83.     if (!CheckRange(next, from, to))
  84.     return;
  85.  
  86.     if (HighWaterMark(shift))
  87.     Expand(GrowBy(size+shift));
  88.  
  89.     if (shift < 0)
  90.     BCOPY(&cont[to], &cont[to+shift], next-to);
  91.     else if (shift > 0)
  92.     BCOPY(&cont[from], &cont[from+shift], next-from);
  93.  
  94.     //---- insert pasted text
  95.     BCOPY(ct->cont, &cont[from], ct->next);
  96.     next += shift;
  97.     if (LowWaterMark())
  98.     Expand(size/2);
  99.     if (buf) {
  100.     delete buf;
  101.     delete ct;
  102.     }
  103.     Text::Paste(paste, from, to);
  104.     Send(cIdNone, eTextReplaced, changeRec(from, to, paste->Size()));     
  105. }
  106.  
  107. void CheapText::Copy(Text *save, int from, int to)
  108. {
  109.     if (!CheckRange(next,from,to) || save == 0)
  110.     return;
  111.  
  112.     if (!save->IsKindOf(CheapText)) { // convert
  113.     int s= to - from;
  114.     byte *buf= new byte[s+1];
  115.     BCOPY(&cont[from], buf, s);
  116.     save->ReplaceWithStr(buf, s);
  117.     delete buf;
  118.     return;
  119.     }
  120.  
  121.     CheapText *ct= (CheapText *)save;    
  122.     register int nSave= to-from;
  123.  
  124.     if (ct->size < nSave) 
  125.     ct->Expand(nSave);
  126.  
  127.     BCOPY(&cont[from], ct->cont, nSave);
  128.     ct->next= nSave;
  129. }
  130.  
  131. void CheapText::CopyInStr(byte *str, int size, int from, int to)
  132. {
  133.     if (!CheckRange(next, from, to) || str == 0)
  134.     return;
  135.  
  136.     register int l= min(to, from+size-1) - from;
  137.     BCOPY(&cont[from], str, l);
  138.     str[l]= '\0';
  139. }
  140.  
  141. void CheapText::ReplaceWithStr(byte *str, int len)
  142. {
  143.     if (len == -1)
  144.     len= strlen((char*)str);
  145.     if (size < len) 
  146.     Expand(len);
  147.     BCOPY(str, cont, len);
  148.     next= len;
  149. }
  150.  
  151. void CheapText::SetFStringVL(char *fmt, va_list va)
  152. {
  153.     Empty();
  154.     char *buf= strvprintf(fmt, va);
  155.     int len= strlen(buf); 
  156.     if (size < len) 
  157.     Expand(len);
  158.     BCOPY((byte*)buf, (byte*)cont, len);
  159.     next= len;
  160.     SafeDelete(buf);
  161. }
  162.  
  163. byte *CheapText::GetTextAt(int from, int to)
  164. {
  165.     if (!CheckRange(next, from, to))
  166.     return 0;
  167.     return &cont[from];
  168. }
  169.  
  170. int CheapText::Search(RegularExp *rex, int *nMatched, int start, int range, 
  171.                          bool forward)
  172. {
  173.     int pos;
  174.  
  175.     if (forward) 
  176.     pos= rex->SearchForward((char*)cont, nMatched, start, Size(), range, 0);
  177.     else
  178.     pos= rex->SearchBackward((char*)cont, nMatched, start, Size(), range, 0); 
  179.     return pos;
  180. }
  181.  
  182. TextPtr CheapText::Save(int from, int to)
  183. {
  184.     if (!CheckRange(next, from, to))
  185.     return 0;
  186.     return new CheapText(&cont[from], to-from);
  187. }
  188.  
  189. void CheapText::Insert(byte c, int from, int to)
  190. {
  191.     int shift= to - from + 1;
  192.  
  193.     if (!CheckRange(next, from, to))
  194.     return;
  195.  
  196.     if (HighWaterMark(shift))
  197.     Expand(GrowBy(size+shift));
  198.  
  199.     if (shift < 0)
  200.     BCOPY(&cont[to], &cont[to+next], size-to);
  201.     else if (shift > 0)
  202.     BCOPY(&cont[from], &cont[from+shift], next-from);
  203.  
  204.     cont[from]= c;
  205.     next+= shift;
  206.     if (LowWaterMark())
  207.     Expand(size/2);
  208.     Text::Insert(c, from, to);
  209.     Send(cIdNone, eTextReplaced, changeRec(from, to, 1));     
  210. }
  211.  
  212. byte& CheapText::operator[](int i)
  213. {
  214.     if (!CheckRange(next, i, i))
  215.     i= size-1;
  216.     return cont[i];
  217. }
  218.  
  219. void CheapText::Empty (int)                                         
  220. {
  221.     next= 0; 
  222. }
  223.  
  224. int CheapText::Size()
  225. {
  226.     return next;
  227. }   
  228.  
  229. bool CheapText::IsEmpty() 
  230. {
  231.     return (bool) (next == 0);
  232. }
  233.  
  234. bool CheapText::IsEqual (ObjPtr text)                                         
  235. {
  236.     if (!text->IsKindOf(CheapText))
  237.     return FALSE;
  238.     CheapText *t= (CheapText *) text;   
  239.     if (next != t->next) 
  240.     return FALSE;
  241.     return (bool) (BCMP(cont, t->cont, next) == 0);
  242. }
  243.  
  244. unsigned long CheapText::Hash ()                                         
  245. {
  246.     register unsigned long hash;
  247.     register byte *p;
  248.  
  249.     for (hash= 0, p= cont; p < cont+Size(); p++)
  250.     hash= (hash << 1) ^ *p;
  251.     return hash;
  252. }
  253.  
  254. bool CheapText::IsEqualStr (byte *t)                                         
  255. {
  256.     if (next != strlen((char*)t)) 
  257.     return FALSE;
  258.     return (bool) (BCMP(cont, t, next) == 0);
  259. }
  260.  
  261. void CheapText::Expand (int newSize)                                         
  262. {
  263.     if (newSize == 0)
  264.     newSize= size * 2;
  265.  
  266.     if (newSize < Size())  // texts never shrink
  267.     return;
  268.     cont= (byte*) Realloc(cont, newSize);
  269.     next= min(newSize, next);
  270.     size= newSize;
  271. }
  272.  
  273. TextIter *CheapText::MakeIterator(int from, int to)
  274. {
  275.     return new CheapTextIter(this,from,to);
  276. }
  277.  
  278. ostream& CheapText::PrintOn(ostream& s)
  279. {
  280.     Text::PrintOn(s); 
  281.     s << font SP << ink SP;
  282.     return PrintString(s, cont, next);
  283. }
  284.  
  285. istream& CheapText::ReadFrom(istream& s)
  286. {
  287.     SafeDelete(cont);
  288.     Text::ReadFrom(s);
  289.     s >> font >> ink;
  290.     ReadString(s, &cont, &size);
  291.     next= size;
  292.     return s;
  293. }
  294.  
  295. ostream& CheapText::PrintOnAsPureText (ostream& s)
  296. {
  297.     int sz= Size();
  298.  
  299.     for (int i= 0; i < sz; i++)
  300.     s.put(CharAt(i));
  301.     return s;
  302. }
  303.  
  304. istream& CheapText::ReadFromAsPureText (istream& s, long sizeHint)
  305. {
  306.     char ch;
  307.  
  308.     if (sizeHint > 0) {
  309.     int delta= (int)(sizeHint - size); // !!!
  310.     if (delta > 0)
  311.         Expand(delta + 50);
  312.     }
  313.     next= 0; 
  314.     while (s.get(ch)) {
  315.     if (HighWaterMark(1))
  316.         Expand(GrowBy(size+1));
  317.     cont[next++] = ch;
  318.     }
  319.     if (!s.eof())
  320.     Error("ReadFromAsPureText", "something strange happened");
  321.     return s;
  322. }
  323.  
  324. int CheapText::TextWidth(int from, int to)
  325. {
  326.     if (!CheckRange(next, from ,to))
  327.     return 0;
  328.  
  329.     register int w= 0;
  330.     for (int i= from; i < to; i++) {
  331.     if (CharAt(i) == '\t') 
  332.         w+= Tabulate(w); 
  333.     else
  334.         w+= font->Width (CharAt(i));
  335.     }
  336.     return w;
  337. }
  338.  
  339. void CheapText::DrawText(int from, int to, Rectangle)
  340. {
  341.     if (!CheckRange(next, from, to))
  342.     return;
  343.  
  344.     SetDrawingState(from);
  345.     Point start= GrGetTextPos();
  346.     byte c;
  347.     for (int i= from; i < to; i++) 
  348.     if ((c= CharAt(i)) == '\t') 
  349.         GrTextAdvance(Tabulate(GrGetTextPos().x-start.x)); 
  350.     else
  351.         GrDrawChar(c);
  352. }
  353.  
  354. //----- class CheapTextIter ---------------------------------------------
  355.  
  356. CheapTextIter::CheapTextIter(Text *s, int from, int to) : TextIter(s, from, to)
  357. {
  358.     if (!s->IsKindOf(CheapText))
  359.     Error("CheapTextIter::CheapTextIter", "CheapText expected");
  360.     font= s->GetFont();
  361. }
  362.  
  363. int CheapTextIter::operator()()      // returns cEOT at end
  364. {
  365.     return (ce == upto ? cEOT : ((CheapText*)ct)->cont[ce++]);
  366. }
  367.  
  368. int CheapTextIter::operator()(int *w, LineDesc* ld)  
  369. {
  370.     CheapText *ctp = (CheapText*)ct;
  371.     int ch;
  372.  
  373.     if (ld) 
  374.     ld->FromFont(font);
  375.     unget= ce;
  376.     *w= 0;
  377.     if (ce == upto)
  378.     return cEOT;
  379.     ch= ctp->cont[ce++];
  380.     *w= font->Width(ch);
  381.     return ch;
  382. }
  383.  
  384. int CheapTextIter::Line(LineDesc* ld)  
  385. {
  386.     CheapText *ctp = (CheapText*)ct;
  387.     if (ld) 
  388.     ld->FromFont(font);
  389.  
  390.     unget= ce;
  391.     if (ce == upto) {
  392.     // special case if last line is empty
  393.     int last= ctp->cont[ce-1];
  394.     ce++;
  395.     if (last == '\n' || last == '\r') 
  396.         return upto;
  397.     }
  398.     if (ce > upto)
  399.     return cEOT;
  400.  
  401.     while (ce < upto) {
  402.     int ch= ctp->cont[ce++];
  403.     if (ch == '\n' || ch == '\r')
  404.         break;
  405.     }
  406.     return ce;
  407. }
  408.  
  409. int CheapTextIter::Token(int *w,LineDesc* ld)  
  410. {
  411.     CheapText *ctp = (CheapText*)ct;
  412.     unget= ce;
  413.     *w = 0;
  414.     if (ld) 
  415.     ld->FromFont(font);
  416.     if (ce >= upto)
  417.     return cEOT;
  418.  
  419.     register int ch= ctp->CharAt(ce);
  420.     if (Isspace(ch)) {
  421.     *w = font->Width(ch);
  422.     ce++;
  423.     return (ch);
  424.     }
  425.     while (ce < upto && !Isspace(ctp->CharAt(ce))) {
  426.     ch = ctp->CharAt(ce++);
  427.     *w += font->Width(ch);
  428.     }
  429.     return (ch);
  430. }
  431.